package com.hhl.lamda.sortmap;

import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author HHL
 * @description
 * @date 2018/11/19 - 10:19
 */
public class SortMap {

    public static void main(String[] args) {

        Map<String, Integer> unsortMap = new HashMap<>();
        unsortMap.put("z", 10);
        unsortMap.put("b", 5);
        unsortMap.put("a", 6);
        unsortMap.put("c", 20);
        unsortMap.put("d", 1);
        unsortMap.put("e", 7);
        unsortMap.put("y", 8);
        unsortMap.put("n", 99);
        unsortMap.put("g", 50);
        unsortMap.put("m", 2);
        unsortMap.put("f", 9);

        System.out.println("Original...");
        // {a=6, b=5, c=20, d=1, e=7, f=9, g=50, y=8, z=10, m=2, n=99}
        System.out.println(unsortMap);
        System.out.println();




        // sort by keys, a,b,c..., and return a new LinkedHashMap
        // toMap() will returns HashMap by default, we need LinkedHashMap to keep the order.
//        keySet是键的集合，Set里面的类型即key的类型
//        entrySet是 键-值 对的集合，Set里面的类型是Map.Entry
        Map<String, Integer> result = unsortMap.entrySet().stream() // 将 entrySet 键-值 对的集合 转化为 stream
                .sorted(Map.Entry.comparingByKey()) // 循环获取 entrySet 键-值 对的集合 里的 Map.Entry 对象，并按照 key 值排序
                .collect(Collectors.toMap(    // 收集排好序的  Map.Entry 对象，将其转化为 map
                        Map.Entry::getKey, Map.Entry::getValue,  // 将 Map.Entry 对象 的 key 和 value 取出
                        (oldValue, newValue) -> oldValue, LinkedHashMap::new // 将旧的 value 值 存入LinkedHashMap
                        // 使用 LinkedHashMap， 使整个 按照 key 值排序之后的  entrySet 键-值 对的集合 顺序不变
                ));



        // 法二：
        //Alternative way to sort a Map by keys, and put it into the "result" map
        Map<String, Integer> result2 = new LinkedHashMap<>();
        unsortMap.entrySet().stream() // 将 entrySet 键-值 对的集合 转化为 stream
                .sorted(Map.Entry.comparingByKey()) // 循环获取 entrySet 键-值 对的集合 里的 Map.Entry 对象，并按照 key 值排序
                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));
        // 按照排序好的 entrySet 键-值 对的集合，循环取出里面的 Map.Entry 对象，将其按顺序放进 LinkedHashMap 里面


        System.out.println("Sorted...");
//        {a=6, b=5, c=20, d=1, e=7, f=9, g=50, m=2, n=99, y=8, z=10}
//        {a=6, b=5, c=20, d=1, e=7, f=9, g=50, m=2, n=99, y=8, z=10}
        System.out.println(result);
        System.out.println(result2);




        //sort by values, and reserve it, 10,9,8,7,6...
        Map<String, Integer> result3 = unsortMap.entrySet().stream()
                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue, LinkedHashMap::new));


        //Alternative way
        Map<String, Integer> result4 = new LinkedHashMap<>();
        unsortMap.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                .forEachOrdered(x -> result4.put(x.getKey(), x.getValue()));

        System.out.println("Sorted...");
//        result3{n=99, g=50, c=20, z=10, f=9, y=8, e=7, a=6, b=5, m=2, d=1}
//        result4{n=99, g=50, c=20, z=10, f=9, y=8, e=7, a=6, b=5, m=2, d=1}
        System.out.print("result3" + result3);
        System.out.println();
        System.out.print("result4" + result4);
        System.out.println();



    }
}
